package main

// 1. Hello world
//func main()  {
//	fmt.Println("Hello world")
//}

// 2. 值
//
//func main() {
//
//	// 字符串拼接.
//	fmt.Println("go" + "lang")
//
//	// Integers and floats.
//	fmt.Println("1+1 =", 1+1)
//	fmt.Println("7.0/3.0 =", 7.0/3.0)
//
//	// 布尔运算
//	fmt.Println(true && false)
//	fmt.Println(true || false)
//	fmt.Println(!true)
//}

//3.变量
//func main() {
//
//	// `var` declares 1 or more variables.
//	var a = "initial"
//	fmt.Println(a)
//
//	// You can declare multiple variables at once.
//	var b, c int = 1, 2
//	fmt.Println(b, c)
//
//	// Go will infer the type of initialized variables.
//	var d = true
//	fmt.Println(d)
//
//	// Variables declared without a corresponding
//	// initialization are _zero-valued_. For example, the
//	// zero value for an `int` is `0`.
//	var e int
//	fmt.Println(e)
//
//	// The `:=` syntax is shorthand for declaring and
//	// initializing a variable, e.g. for
//	// `var f string = "apple"` in this case.
//	f := "apple"
//	fmt.Println(f)
//}

//4.常量
//// `const` declares a constant value.
//const s string = "constant"
//
//func main() {
//	fmt.Println(s)
//
//	// A `const` statement can appear anywhere a `var`
//	// statement can.
//	const n = 500000000
//
//	// Constant expressions perform arithmetic with
//	// arbitrary precision.
//	const d = 3e20 / n
//	fmt.Println(d)
//
//	// A numeric constant has no type until it's given
//	// one, such as by an explicit conversion.
//	fmt.Println(int64(d))
//
//	// A number can be given a type by using it in a
//	// context that requires one, such as a variable
//	// assignment or function call. For example, here
//	// `math.Sin` expects a `float64`.
//	fmt.Println(math.Sin(n))
//}

//5.for

//func main()  {
//	i:=1
//	for i<3 {
//		fmt.Println(i)
//		i=i+1
//	}
//	for j := 7; j < 9; j++ {
//		fmt.Println(j)
//	}
//	for  {
//		fmt.Println("loop")
//		break
//	}
//	for n:=0;n<5;n++ {
//		if n%2==0 {
//			continue
//		}
//		fmt.Println(n)
//	}
//}

//6.if/else

//func main()  {
//	if 7%2==0 {
//		fmt.Println("7 is even")
//	}else {
//		fmt.Println("7 is odd")
//	}
//	if 8%4==0 {
//		fmt.Println("8 is divisible by 4")
//	}
//	if num:=9;num<0 {
//		fmt.Println(num, "is negative")
//	} else if num < 10 {
//		fmt.Println(num, "has 1 digit")
//	} else {
//		fmt.Println(num, "has multiple digits")
//	}
//
//}

//7.switch
//func main()  {
//	i:=2
//	fmt.Print("Write ", i, " as ")
//	switch i {
//	case 1:
//		fmt.Println("one")
//	case 2:
//		fmt.Println("two")
//	case 3:
//		fmt.Println("three")
//	}
//	switch time.Now().Weekday() {
//	case time.Saturday,time.Sunday:
//		fmt.Println("It's the weekend")
//	default:
//		fmt.Println("It's a weekday")
//	}
//	t:=time.Now()
//	switch  {
//	case t.Hour()<12:
//		fmt.Println("It's before noon")
//	default:
//		fmt.Println("It's after noon")
//	}
//
//	whatAmI:= func(i interface{}) {
//		switch t:=i.(type) {
//		case bool:
//			fmt.Println("I'm a bool")
//		case int:
//			fmt.Println("I'm an int")
//		default:
//			fmt.Printf("Don't know type %T\n", t)
//		}
//	}
//	whatAmI(true)
//	whatAmI(1)
//	whatAmI("hey")
//
//}

//8.数组
//func main()  {
//	var a [5]int
//	fmt.Println("emp",a)
//	a[4]=100
//	fmt.Println("set:",a)
//	fmt.Println("get:",a[4])
//	fmt.Println("len:",len(a))
//
//	b:=[5]int{1,2,3,4,5}
//	fmt.Println("dcl:",b)
//	var twoD [2][3]int
//	for i := 0; i < 2; i++ {
//		for j := 0; j < 3; j++ {
//			twoD[i][j]=i+j
//		}
//	}
//	fmt.Println("2d",twoD)
//}

//9.切片 slices

//func main()  {
//	s:=make([]string,3)
//	fmt.Println("emp:",s)
//	s[0] = "a"
//	s[1] = "b"
//	s[2] = "c"
//	fmt.Println("set:",s)
//	fmt.Println("get:",s[2])
//	fmt.Println("len:",len(s))
//	s=append(s,"d")
//	s=append(s,"e","f")
//	fmt.Println("apd:",s)
//	c:=make([]string,len(s))
//	copy(c,s)
//	fmt.Println("cpy:",c)
//	l:=s[2:5]
//	fmt.Println("sl1:",l)
//	l=s[:5]
//	fmt.Println("sl2:",l)
//	l=s[2:]
//	fmt.Println("sl3:",l)
//	t:=[]string{"g","h","i"}
//	fmt.Println("dcl:",t)
//
//	twoD:= make([][]int,3)
//	for i := 0; i < 3; i++ {
//		innerLen :=i+1
//		twoD[i] = make([]int,innerLen)
//		for j := 0; j < innerLen; j++ {
//			twoD[i][j]=i+j
//		}
//	}
//	fmt.Println("2d:",twoD)
//
//}

//10.map
//func main()  {
//	m:= make(map[string]int)
//	m["k1"]=7
//	m["k2"]=13
//	fmt.Println("map:",m)
//	v1:=m["k1"]
//	fmt.Println("v1:",v1)
//	fmt.Println("len:",len(m))
//	delete(m,"k2")
//	fmt.Println("map:",m)
//	_,prs:=m["k2"]
//	fmt.Println("prs",prs)
//	n:=map[string]int{
//		"foo":1,
//		"bar":2,
//	}
//	fmt.Println("map:",n)
//}

//11.range

//func main()  {
//	nums:= []int{2,3,4}
//	sum:=0
//	for _,num:=range nums{
//		sum +=num
//	}
//	fmt.Println("sum:",sum)
//	for i,num:=range nums{
//		if num==3 {
//			fmt.Println("index:",i)
//		}
//	}
//	kvs:=map[string]string{"a":"apple","b":"banana"}
//	for k,v:=range kvs{
//		fmt.Println("%s -> %s\n",k,v)
//	}
//	for k:=range kvs{
//		fmt.Println("key:",k)
//	}
//	for i,c:=range "go"{
//		fmt.Println(i,c)
//	}
//}

//12.函数

//func plus(a int,b int) int  {
//	return a+b
//}
//func plusPlus(a,b,c int) int  {
//	return  a+b+c
//}
//func main()  {
//	res:= plus(1,2)
//	fmt.Println("1+2=",res)
//	res = plusPlus(1,2,3)
//	fmt.Println("1+2+3=",res)
//}

//13.多返回值

//func vals()(int,int)  {
//	return 3,7
//}
//func main()  {
//	a,b:=vals()
//	fmt.Println(a,b)
//	_,c:=vals()
//	fmt.Println(c)
//}

//14.变参函数

//func sum(nums ...int)  {
//	fmt.Print(nums,"")
//	total:=0
//	for _,num:=range nums{
//		total+=num
//	}
//	fmt.Println(total)
//}
//func main()  {
//	sum(1,2)
//	sum(1,2,3)
//	nums:=[]int{1,2,3,4}
//	sum(nums...)
//}

//15.闭包

//func intSeq() func()int  {
//	i:=0
//	return func() int {
//		i++
//		return i
//	}
//}
//func main()  {
//	nextInt:=intSeq()
//	fmt.Println(nextInt())
//	fmt.Println(nextInt())
//	fmt.Println(nextInt())
//	newInts:=intSeq()
//	fmt.Println(newInts())
//}

//16.递归
//func fact(n int) int {
//	if n==0{
//		return 1
//	}
//	return n*fact(n-1)
//}
//func main()  {
//	fmt.Println(fact(7))
//}

//17.指针 pointer
//func  zeroval(ival int)  {
//	ival = 0
//}
//func zeroptr(iptr *int)  {
//	*iptr = 0
//}
//func main()  {
//	i:=1
//	fmt.Println("initial:",i)
//	zeroval(i)
//	fmt.Println("zeroval",i)
//	zeroptr(&i)
//	fmt.Println("zeroptr",i)
//	fmt.Println("pointer",&i)
//}

//18.结构体

//type person struct {
//	name string
//	age  int
//}
//
//func newPerson(name string) *person  {
//	p:=person{name:name}
//	p.age = 42
//	return &p
//}
//func main()  {
//	fmt.Println(person{"Bob",20})
//	fmt.Println(person{"Aob",30})
//	fmt.Println(person{name: "Aob"})
//	fmt.Println(&person{name: "Aob",age: 40})
//	fmt.Println(newPerson("jon"))
//	s := person{name: "Sean", age: 50}
//	fmt.Println(s.name)
//
//	// You can also use dots with struct pointers - the
//	// pointers are automatically dereferenced.
//	sp := &s
//	fmt.Println(sp.age)
//
//	// Structs are mutable.
//	sp.age = 51
//	fmt.Println(sp.age)
//}

//19.方法
//type rect struct {
//	width,height int
//}
//// 面积
//func (r *rect) area()int  {
//	return r.width*r.height
//}
//// 周长
//func (r *rect) perim() int  {
//	return 2*r.width+2*r.height
//}
//func main()  {
//	r:=rect{width: 10,height: 5}
//	fmt.Println("area:",r.area())
//	fmt.Println("perim:",r.perim())
//
//	rp:=&r
//	fmt.Println("area:",rp.area())
//	fmt.Println("perim:",rp.perim())
//}

//20.接口
//type geometry interface {
//	area() float64
//	perim() float64
//}
//
//type rect struct {
//	width, height float64
//}
//type circle struct {
//	radius float64
//}
//func (r rect) area() float64 {
//	return r.width * r.height
//}
//func (r rect) perim() float64 {
//	return 2*r.width + 2*r.height
//}
//func (c circle) area() float64 {
//	return math.Pi * c.radius * c.radius
//}
//func (c circle) perim() float64 {
//	return 2 * math.Pi * c.radius
//}
//func measure(g geometry) {
//	fmt.Println(g)
//	fmt.Println(g.area())
//	fmt.Println(g.perim())
//}
//func main() {
//	r := rect{width: 3, height: 4}
//	c := circle{radius: 5}
//
//	// The `circle` and `rect` struct types both
//	// implement the `geometry` interface so we can use
//	// instances of
//	// these structs as arguments to `measure`.
//	measure(r)
//	measure(c)
//}

//21.错误
//func f1(arg int)(int,error)  {
//	if arg==42 {
//		return -1,errors.New("can't work with 42")
//	}
//	return arg+3,nil
//}
//type argError struct {
//	arg int
//	prob string
//}
//
//func (e *argError)Error() string  {
//	return fmt.Sprintf("%d - %s",e.arg,e.prob)
//}
//func f2(arg int) (int,error)  {
//	if arg ==42 {
//		return -1,&argError{arg,"can't work with it"}
//	}
//	return arg+3,nil
//}
//func main()  {
//	for _,i:=range []int{7,42}{
//		if r,e:=f1(i);e!=nil {
//			fmt.Println("f1 failed:", e)
//		} else {
//			fmt.Println("f1 worked:", r)
//		}
//	}
//	for _,i:=range []int{7,42}{
//		if r,e:=f2(i);e!=nil {
//			fmt.Println("f2 failed:", e)
//		} else {
//			fmt.Println("f2 worked:", r)
//		}
//	}
//	_, e := f2(42)
//	if ae, ok := e.(*argError); ok {
//		fmt.Println(ae.arg)
//		fmt.Println(ae.prob)
//	}
//}

//22.协程
//func f(form string)  {
//	for i := 0; i < 3; i++ {
//		fmt.Println(form,":",i)
//	}
//}
//func main()  {
//	f("direct")
//	go f("goroutine")
//	go func(msg string) {
//		fmt.Println(msg)
//	}("going")
//	time.Sleep(time.Second)
//	fmt.Println("done")
//}
//23.Channel
//func main()  {
//	messages:=make(chan string)
//	go func() {messages<-"ping"}()
//	msg:=<-messages
//	fmt.Println(msg)
//}
//24.Channel 缓冲
//func main()  {
//	messages:=make(chan string,2)
//	messages<-"buffered"
//	messages<-"channel"
//	fmt.Println(<-messages)
//	fmt.Println(<-messages)
//}
//25.Channel 同步
//func worker(done chan bool)  {
//	fmt.Print("working...\n")
//	time.Sleep(time.Second)
//	fmt.Println("done")
//	done <- true
//}
//func main()  {
//	done:=make(chan bool,1)
//	go worker(done)
//	<-done
//}
//26.Channel 方向
//func ping(pings chan<- string,msg string)  {
//	pings<-msg
//}
//func pong(pings<-chan string,pongs chan <-string)  {
//	msg:=<-pings
//	pongs<-msg
//}
//
//func main()  {
//	pings:=make(chan string,1)
//	pongs:=make(chan string,1)
//	ping(pings,"passed message")
//	pong(pings,pongs)
//	fmt.Println(<-pongs)
//}
//27.select
//func main()  {
//	c1:= make(chan string)
//	c2:= make(chan string)
//	go func() {
//		time.Sleep(1*time.Second)
//		c1<-"one"
//	}()
//	go func() {
//		time.Sleep(2*time.Second)
//		c2<-"two"
//	}()
//	for i := 0; i < 2; i++ {
//		select {
//		case msg1:=<-c1:
//			fmt.Println("received",msg1)
//		case msg2:=<-c2:
//			fmt.Println("received",msg2)
//
//		}
//	}
//
//}
//28.超时控制

//func main()  {
//	c1 := make(chan string, 1)
//	go func() {
//		time.Sleep(2 * time.Second)
//		c1 <- "result 1"
//	}()
//
//	select {
//	case res := <-c1:
//		fmt.Println(res)
//	case <-time.After(1 * time.Second):
//		fmt.Println("timeout 1")
//	}
//	c2 := make(chan string, 1)
//	go func() {
//		time.Sleep(2 * time.Second)
//		c2 <- "result 2"
//	}()
//	select {
//	case res := <-c2:
//		fmt.Println(res)
//	case <-time.After(3 * time.Second):
//		fmt.Println("timeout 2")
//	}
//}

//29.非阻塞 Channel
//
//func main()  {
//	messages:=make(chan string)
//	signals:=make(chan string)
//	select {
//	case msg := <-messages:
//		fmt.Println("received message", msg)
//	default:
//		fmt.Println("no message received")
//
//	}
//	msg:="hi"
//	select {
//	case messages <- msg:
//		fmt.Println("sent message", msg)
//	default:
//		fmt.Println("no message sent")
//	}
//	select {
//	case msg := <-messages:
//		fmt.Println("received message", msg)
//	case sig := <-signals:
//		fmt.Println("received signal", sig)
//	default:
//		fmt.Println("no activity")
//	}
//}

//30.关闭 Channel

//func main()  {
//	jobs := make(chan int, 5)
//	done := make(chan bool)
//
//	go func() {
//		for {
//			j, more := <-jobs
//			if more {
//				fmt.Println("received job", j)
//			} else {
//				fmt.Println("received all jobs")
//				done <- true
//				return
//			}
//		}
//	}()
//
//	for j := 1; j <= 3; j++ {
//		jobs <- j
//		fmt.Println("sent job", j)
//	}
//	close(jobs)
//	fmt.Println("sent all jobs")
//
//	<-done
//}

//31.range Channel
//func main()  {
//	queue := make(chan string, 2)
//	queue <- "one"
//	queue <- "two"
//	close(queue)
//
//	for elem := range queue {
//		fmt.Println(elem)
//	}
//}
//32.定时器
//func main()  {
//	p:=fmt.Println
//	now:=time.Now()
//	p(now)
//	then:=time.Date(
//		2009,11,17,20,34,58,651387237,time.UTC)
//	p(then)
//	p(then.Year())
//	p(then.Month())
//	p(then.Day())
//	p(then.Hour())
//	p(then.Minute())
//	p(then.Second())
//	p(then.Nanosecond())
//	p(then.Location())
//	p(then.Weekday())
//	p(then.Before(now))
//	p(then.After(now))
//	p(then.Equal(now))
//	diff:=now.Sub(then)
//	p(diff)
//	p(diff.Hours())
//	p(diff.Minutes())
//	p(diff.Seconds())
//	p(diff.Nanoseconds())
//	p(then.Add(diff))
//	p(then.Add(-diff))
//}

//33.Ticker
//func main()  {
//	ticker := time.NewTicker(500 * time.Millisecond)
//	done := make(chan bool)
//
//	go func() {
//		for {
//			select {
//			case <-done:
//				return
//			case t := <-ticker.C:
//				fmt.Println("Tick at", t)
//			}
//		}
//	}()
//	time.Sleep(1600 * time.Millisecond)
//	ticker.Stop()
//	done <- true
//	fmt.Println("Ticker stopped")
//}

//34.Worker Pool
//func worker(id int, jobs <-chan int, results chan<- int) {
//	for j := range jobs {
//		fmt.Println("worker", id, "started  job", j)
//		time.Sleep(time.Second)
//		fmt.Println("worker", id, "finished job", j)
//		results <- j * 2
//	}
//}
//
//func main() {
//	const numJobs = 5
//	jobs := make(chan int, numJobs)
//	results := make(chan int, numJobs)
//
//	for w := 1; w <= 3; w++ {
//		go worker(w, jobs, results)
//	}
//
//	for j := 1; j <= numJobs; j++ {
//		jobs <- j
//	}
//	close(jobs)
//	for a := 1; a <= numJobs; a++ {
//		<-results
//	}
//}

//35.频率限制 rate limiting

//func main()  {
//	requests:=make(chan int,5)
//	for i := 0; i < 5; i++ {
//		requests<-i
//	}
//	close(requests)
//	limter:=time.Tick(200*time.Millisecond)
//
//	for req := range requests{
//		<-limter
//		fmt.Println("request",req,time.Now())
//	}
//	burstyLimiter:=make(chan time.Time,3)
//	for i := 0; i <3 ; i++ {
//		burstyLimiter<- time.Now()
//	}
//	go func() {
//		for t:=range time.Tick(200*time.Millisecond){
//			burstyLimiter<-t
//		}
//	}()
//	burstyRequests := make(chan int, 5)
//	for i := 1; i <= 5; i++ {
//		burstyRequests <- i
//	}
//	close(burstyRequests)
//	for req := range burstyRequests {
//		<-burstyLimiter
//		fmt.Println("request", req, time.Now())
//	}
//}

//36.原子计数器 atomic-counters

//func main()  {
//var ops uint64
//var wg sync.WaitGroup
//for i := 0; i < 50; i++ {
//	wg.Add(1)
//	go func() {
//		for c := 0; c < 1000; c++ {
//			atomic.AddUint64(&ops,1)
//		}
//		wg.Done()
//	}()
//}
//wg.Wait()
//fmt.Println("ops:",ops)
//}

//37.互斥锁  mutexes
//func main() {
//	var state = make(map[int]int)
//	var mutex = &sync.Mutex{}
//	var readOps uint64
//	var writeOps uint64
//	for r := 0; r < 100; r++ {
//		go func() {
//			total:=0
//			for  {
//				key:=rand.Intn(5)
//				mutex.Lock()
//				total+=state[key]
//				mutex.Unlock()
//				atomic.AddUint64(&readOps,1)
//				time.Sleep(time.Millisecond)
//
//			}
//		}()
//	}
//	for w := 0; w < 10; w++ {
//		go func() {
//			for  {
//				key:=rand.Intn(5)
//				val:=rand.Intn(100)
//				mutex.Lock()
//				state[key]=val
//				mutex.Unlock()
//				atomic.AddUint64(&writeOps,1)
//				time.Sleep(time.Millisecond)
//			}
//		}()
//	}
//	time.Sleep(time.Second)
//	readOpsFinal:=atomic.LoadUint64(&readOps)
//	fmt.Println("readOps:",readOpsFinal)
//	writeOpsFinal:=atomic.LoadUint64(&writeOps)
//	fmt.Println("writeOps:",writeOpsFinal)
//	mutex.Lock()
//	fmt.Println("state:",state)
//	mutex.Unlock()
//}

//38.协程状态共享
//type readOp struct {
//	key  int
//	resp chan int
//}
//type writeOp struct {
//	key  int
//	val  int
//	resp chan bool
//}
//func main()  {
//	var readOps uint64
//	var writeOps uint64
//	reads := make(chan readOp)
//	writes := make(chan writeOp)
//
//
//	go func() {
//		var state = make(map[int]int)
//		for {
//			select {
//			case read := <-reads:
//				read.resp <- state[read.key]
//			case write := <-writes:
//				state[write.key] = write.val
//				write.resp <- true
//			}
//		}
//	}()
//	for r := 0; r < 100; r++ {
//		go func() {
//			for {
//				read := readOp{
//					key:  rand.Intn(5),
//					resp: make(chan int)}
//				reads <- read
//				<-read.resp
//				atomic.AddUint64(&readOps, 1)
//				time.Sleep(time.Millisecond)
//			}
//		}()
//	}
//	for w := 0; w < 10; w++ {
//		go func() {
//			for {
//				write := writeOp{
//					key:  rand.Intn(5),
//					val:  rand.Intn(100),
//					resp: make(chan bool)}
//				writes <- write
//				<-write.resp
//				atomic.AddUint64(&writeOps, 1)
//				time.Sleep(time.Millisecond)
//			}
//		}()
//	}
//	time.Sleep(time.Second)
//
//	// Finally, capture and report the op counts.
//	readOpsFinal := atomic.LoadUint64(&readOps)
//	fmt.Println("readOps:", readOpsFinal)
//	writeOpsFinal := atomic.LoadUint64(&writeOps)
//	fmt.Println("writeOps:", writeOpsFinal)
//}
//39.排序
//func main()  {
//	strs := []string{"c", "a", "b"}
//	sort.Strings(strs)
//	fmt.Println("Strings:", strs)
//
//	// An example of sorting `int`s.
//	ints := []int{7, 2, 4}
//	sort.Ints(ints)
//	fmt.Println("Ints:   ", ints)
//
//	// We can also use `sort` to check if a slice is
//	// already in sorted order.
//	s := sort.IntsAreSorted(ints)
//	fmt.Println("Sorted: ", s)
//}


//40.自定义排序函数
//type byLength []string
//func (s byLength) Len() int {
//	return len(s)
//}
//func (s byLength) Swap(i, j int) {
//	s[i], s[j] = s[j], s[i]
//}
//func (s byLength) Less(i, j int) bool {
//	return len(s[i]) < len(s[j])
//}
//func main() {
//	fruits := []string{"peach", "banana", "kiwi"}
//	sort.Sort(byLength(fruits))
//	fmt.Println(fruits)
//}

//41.Panic
//func main()  {
//	panic("a problem")
//	_,err := os.Create("/tmp/file")
//	if err!=nil {
//		panic(err)
//	}
//}


//42.Defer
//func main()  {
//	f:=createFile("defer.txt")
//	defer closeFile(f)
//	writeFile(f)
//}
//func createFile(p string) *os.File {
//	fmt.Println("creating")
//	f, err := os.Create(p)
//	if err != nil {
//		panic(err)
//	}
//	return f
//}
//func writeFile(f *os.File) {
//	fmt.Println("writing")
//	fmt.Fprintln(f, "data")
//
//}
//func closeFile(f *os.File) {
//	fmt.Println("closing")
//	err := f.Close()
//	// It's important to check for errors when closing a
//	// file, even in a deferred function.
//	if err != nil {
//		fmt.Fprintf(os.Stderr, "error: %v\n", err)
//		os.Exit(1)
//	}
//}

//43.集合操作
//func main()  {
//	var a [5]int
//	fmt.Println("emp:",a)
//	a[4]=100
//	fmt.Println("set:",a)
//	fmt.Println("get:",a[4])
//	fmt.Println("len:",len(a))
//	b:=[5]int{1,2,3,4,5}
//	fmt.Println("dcl:",b)
//	var twoD [2][3]int
//	for i := 0; i < 2; i++ {
//		for j := 0; j < 3; j++ {
//			twoD[i][j]=i+j
//		}
//	}
//
//	fmt.Println("2d:",twoD)
//}
//44.字符串操作
//var p=fmt.Println
//
//func main()  {
//	p("Contains:  ", strings.Contains("test", "es"))
//	p("Count:     ", strings.Count("test", "t"))
//	p("HasPrefix: ", strings.HasPrefix("test", "te"))
//	p("HasSuffix: ", strings.HasSuffix("test", "st"))
//	p("Index:     ", strings.Index("test", "e"))
//	p("Join:      ", strings.Join([]string{"a", "b"}, "-"))
//	p("Repeat:    ", strings.Repeat("a", 5))
//	p("Replace:   ", strings.Replace("foo", "o", "0", -1))
//	p("Replace:   ", strings.Replace("foo", "o", "0", 1))
//	p("Split:     ", strings.Split("a-b-c-d-e", "-"))
//	p("ToLower:   ", strings.ToLower("TEST"))
//	p("ToUpper:   ", strings.ToUpper("test"))
//	p()
//	p("Len: ", len("hello"))
//	p("Char:", "hello"[1])
//
//}

//45.字符串格式化
//type point struct {
//	x,y int
//}
//
//func main()  {
//	p:=point{1,2}
//	fmt.Printf("%v\n",p)
//	fmt.Printf("%+v\n",p)
//	fmt.Printf("%#v\n",p)
//	fmt.Printf("%T\n",p)
//	fmt.Printf("%t\n",true)
//	fmt.Printf("%d\n",123)
//	fmt.Printf("%b\n",14)
//	fmt.Printf("%c\n",33)
//	fmt.Printf("%x\n",456)
//	fmt.Printf("%f\n",78.9)
//	fmt.Printf("%e\n",12340000.0)
//	fmt.Printf("%E\n",12340000.0)
//	fmt.Printf("%s\n","\"string\"")
//	fmt.Printf("%q\n","\"string\"")
//	fmt.Printf("%x\n","hex this")
//	fmt.Printf("%p\n",&p)
//	fmt.Printf("|%6d|%6d|\n", 12, 345)
//	fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)
//	fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)
//	fmt.Printf("|%6s|%6s|\n", "foo", "b")
//	fmt.Printf("|%-6s|%-6s|\n", "foo", "b")
//	s := fmt.Sprintf("a %s", "string")
//	fmt.Println(s)
//	fmt.Fprintf(os.Stderr, "an %s\n", "error")
//
//}


//46.正则表达式 regexp
//func main()  {
//	match, _ := regexp.MatchString("p([a-z]+)ch", "peach")
//	fmt.Println(match)
//	r, _ := regexp.Compile("p([a-z]+)ch")
//	fmt.Println(r.MatchString("peach"))
//	fmt.Println(r.FindString("peach punch"))
//	fmt.Println(r.FindStringIndex("peach punch"))
//	fmt.Println(r.FindStringSubmatch("peach punch"))
//	fmt.Println(r.FindStringSubmatchIndex("peach punch"))
//	fmt.Println(r.FindAllString("peach punch pinch", -1))
//	fmt.Println(r.FindAllStringSubmatchIndex(
//		"peach punch pinch", -1))
//	fmt.Println(r.FindAllString("peach punch pinch", 2))
//	fmt.Println(r.Match([]byte("peach")))
//	r = regexp.MustCompile("p([a-z]+)ch")
//	fmt.Println(r)
//	fmt.Println(r.ReplaceAllString("a peach", "<fruit>"))
//
//	// The `Func` variant allows you to transform matched
//	// text with a given function.
//	in := []byte("a peach")
//	out := r.ReplaceAllFunc(in, bytes.ToUpper)
//	fmt.Println(string(out))
//}


//47.JSON
//type response1 struct {
//	Page   int
//	Fruits []string
//}
//type response2 struct {
//	Page   int      `json:"page"`
//	Fruits []string `json:"fruits"`
//}
//func main()  {
//	bolB, _ := json.Marshal(true)
//	fmt.Println(string(bolB))
//
//	intB, _ := json.Marshal(1)
//	fmt.Println(string(intB))
//
//	fltB, _ := json.Marshal(2.34)
//	fmt.Println(string(fltB))
//
//	strB, _ := json.Marshal("gopher")
//	fmt.Println(string(strB))
//	slcD := []string{"apple", "peach", "pear"}
//	slcB, _ := json.Marshal(slcD)
//	fmt.Println(string(slcB))
//
//	mapD := map[string]int{"apple": 5, "lettuce": 7}
//	mapB, _ := json.Marshal(mapD)
//	fmt.Println(string(mapB))
//	res1D := &response1{
//		Page:   1,
//		Fruits: []string{"apple", "peach", "pear"}}
//	res1B, _ := json.Marshal(res1D)
//	fmt.Println(string(res1B))
//	res2D := &response2{
//		Page:   1,
//		Fruits: []string{"apple", "peach", "pear"}}
//	res2B, _ := json.Marshal(res2D)
//	fmt.Println(string(res2B))
//	byt := []byte(`{"num":6.13,"strs":["a","b"]}`)
//	var dat map[string]interface{}
//	if err := json.Unmarshal(byt, &dat); err != nil {
//		panic(err)
//	}
//	fmt.Println(dat)
//	num := dat["num"].(float64)
//	fmt.Println(num)
//	strs := dat["strs"].([]interface{})
//	str1 := strs[0].(string)
//	fmt.Println(str1)
//	str := `{"page": 1, "fruits": ["apple", "peach"]}`
//	res := response2{}
//	json.Unmarshal([]byte(str), &res)
//	fmt.Println(res)
//	fmt.Println(res.Fruits[0])
//	enc := json.NewEncoder(os.Stdout)
//	d := map[string]int{"apple": 5, "lettuce": 7}
//	enc.Encode(d)
//}
//48.日期时间
//func main()  {
//
//}
//49.Epoch
//func main()  {
//	now := time.Now()
//	secs := now.Unix()
//	nanos := now.UnixNano()
//	fmt.Println(now)
//	millis := nanos / 1000000
//	fmt.Println(secs)
//	fmt.Println(millis)
//	fmt.Println(nanos)
//	fmt.Println(time.Unix(secs, 0))
//	fmt.Println(time.Unix(0, nanos))
//}
//50.日期时间格式化/解析
//func main()  {
//	p := fmt.Println
//	t := time.Now()
//	p(t.Format(time.RFC3339))
//	t1, e := time.Parse(
//		time.RFC3339,
//		"2012-11-01T22:08:41+00:00")
//	p(t1)
//	p(t.Format("3:04PM"))
//	p(t.Format("Mon Jan _2 15:04:05 2006"))
//	p(t.Format("2006-01-02T15:04:05.999999-07:00"))
//	form := "3 04 PM"
//	t2, e := time.Parse(form, "8 41 PM")
//	p(t2)
//	fmt.Printf("%d-%02d-%02dT%02d:%02d:%02d-00:00\n",
//		t.Year(), t.Month(), t.Day(),
//		t.Hour(), t.Minute(), t.Second())
//	ansic := "Mon Jan _2 15:04:05 2006"
//	_, e = time.Parse(ansic, "8:41PM")
//	p(e)
//}
//51.随机数
//func main()  {
//	fmt.Print(rand.Intn(100), ",")
//	fmt.Print(rand.Intn(100))
//	fmt.Println()
//	fmt.Println(rand.Float64())
//	s1 := rand.NewSource(time.Now().UnixNano())
//	r1 := rand.New(s1)
//	fmt.Print(r1.Intn(100), ",")
//	fmt.Print(r1.Intn(100))
//	fmt.Println()
//	s2 := rand.NewSource(42)
//	r2 := rand.New(s2)
//	fmt.Print(r2.Intn(100), ",")
//	fmt.Print(r2.Intn(100))
//	fmt.Println()
//	s3 := rand.NewSource(42)
//	r3 := rand.New(s3)
//	fmt.Print(r3.Intn(100), ",")
//	fmt.Print(r3.Intn(100))
//}
//52.数字解析
//func main()  {
//	f, _ := strconv.ParseFloat("1.234", 64)
//	fmt.Println(f)
//	i, _ := strconv.ParseInt("123", 0, 64)
//	fmt.Println(i)
//	d, _ := strconv.ParseInt("0x1c8", 0, 64)
//	fmt.Println(d)
//	u, _ := strconv.ParseUint("789", 0, 64)
//	fmt.Println(u)
//	k, _ := strconv.Atoi("135")
//	fmt.Println(k)
//	_, e := strconv.Atoi("wat")
//	fmt.Println(e)
//}
//53.URL 解析
//func main()  {
//	s := "postgres://user:pass@host.com:5432/path?k=v#f"
//	u, err := url.Parse(s)
//	if err != nil {
//		panic(err)
//	}
//	fmt.Println(u.Scheme)
//	fmt.Println(u.User)
//	fmt.Println(u.User.Username())
//	p, _ := u.User.Password()
//	fmt.Println(p)
//	fmt.Println(u.Host)
//	host, port, _ := net.SplitHostPort(u.Host)
//	fmt.Println(host)
//	fmt.Println(port)
//	fmt.Println(u.Path)
//	fmt.Println(u.Fragment)
//	fmt.Println(u.RawQuery)
//	m, _ := url.ParseQuery(u.RawQuery)
//	fmt.Println(m)
//	fmt.Println(m["k"][0])
//}

//54.SHA1 哈希
//func main()  {
//	s := "sha1 this string"
//	h := sha1.New()
//	h.Write([]byte(s))
//	bs := h.Sum(nil)
//	fmt.Println(s)
//	fmt.Printf("%x\n", bs)
//}
//55.BASE64 编码
//func main()  {
//	data := "abc123!?$*&()'-=@~"
//	sEnc := base64.StdEncoding.EncodeToString([]byte(data))
//	fmt.Println(sEnc)
//	sDec, _ := base64.StdEncoding.DecodeString(sEnc)
//	fmt.Println(string(sDec))
//	fmt.Println()
//	uEnc := base64.URLEncoding.EncodeToString([]byte(data))
//	fmt.Println(uEnc)
//	uDec, _ := base64.URLEncoding.DecodeString(uEnc)
//	fmt.Println(string(uDec))
//}
//56.环境变量
//func main()  {
//	os.Setenv("FOO", "1")
//	fmt.Println("FOO:", os.Getenv("FOO"))
//	fmt.Println("BAR:", os.Getenv("BAR"))
//	fmt.Println()
//	for _, e := range os.Environ() {
//		pair := strings.SplitN(e, "=", 2)
//		fmt.Println(pair[0])
//	}
//}
//57.cmd 进程派生
//func main()  {
	//argsWithProg := os.Args
	//argsWithoutProg := os.Args[1:]
	//arg := os.Args[3]
	//
	//fmt.Println(argsWithProg)
	//fmt.Println(argsWithoutProg)
	//fmt.Println(arg)


	//wordPtr := flag.String("word", "foo", "a string")
	//numbPtr := flag.Int("numb", 42, "an int")
	//boolPtr := flag.Bool("fork", false, "a bool")
	//var svar string
	//flag.StringVar(&svar, "svar", "bar", "a string var")
	//flag.Parse()
	//
	//fmt.Println("word:", *wordPtr)
	//fmt.Println("numb:", *numbPtr)
	//fmt.Println("fork:", *boolPtr)
	//fmt.Println("svar:", svar)
	//fmt.Println("tail:", flag.Args())



	//fooCmd := flag.NewFlagSet("foo", flag.ExitOnError)
	//fooEnable := fooCmd.Bool("enable", false, "enable")
	//fooName := fooCmd.String("name", "", "name")
	//barCmd := flag.NewFlagSet("bar", flag.ExitOnError)
	//barLevel := barCmd.Int("level", 0, "level")
	//if len(os.Args) < 2 {
	//	fmt.Println("expected 'foo' or 'bar' subcommands")
	//	os.Exit(1)
	//}
	//
	//// Check which subcommand is invoked.
	//switch os.Args[1] {
	//
	//// For every subcommand, we parse its own flags and
	//// have access to trailing positional arguments.
	//case "foo":
	//	fooCmd.Parse(os.Args[2:])
	//	fmt.Println("subcommand 'foo'")
	//	fmt.Println("  enable:", *fooEnable)
	//	fmt.Println("  name:", *fooName)
	//	fmt.Println("  tail:", fooCmd.Args())
	//case "bar":
	//	barCmd.Parse(os.Args[2:])
	//	fmt.Println("subcommand 'bar'")
	//	fmt.Println("  level:", *barLevel)
	//	fmt.Println("  tail:", barCmd.Args())
	//default:
	//	fmt.Println("expected 'foo' or 'bar' subcommands")
	//	os.Exit(1)
	//}
//}
//58.进程替换
//func main()  {
//	dateCmd := exec.Command("date")
//	dateOut, err := dateCmd.Output()
//	if err != nil {
//		panic(err)
//	}
//	fmt.Println("> date")
//	fmt.Println(string(dateOut))
//	grepCmd := exec.Command("grep", "hello")
//	grepIn, _ := grepCmd.StdinPipe()
//	grepOut, _ := grepCmd.StdoutPipe()
//	grepCmd.Start()
//	grepIn.Write([]byte("hello grep\ngoodbye grep"))
//	grepIn.Close()
//	grepBytes, _ := ioutil.ReadAll(grepOut)
//	grepCmd.Wait()
//	fmt.Println("> grep hello")
//	fmt.Println(string(grepBytes))
//	lsCmd := exec.Command("bash", "-c", "ls -a -l -h")
//	lsOut, err := lsCmd.Output()
//	if err != nil {
//		panic(err)
//	}
//	fmt.Println("> ls -a -l -h")
//	fmt.Println(string(lsOut))
//}


//  59, 读写文件
//func check(e error) {
//	if e != nil {
//		panic(e)
//	}
//}

//func main() {
//
//	dat, err := ioutil.ReadFile("./tmp/dat")
//	check(err)
//	fmt.Print(string(dat))
//
//	f, err := os.Open("./tmp/dat")
//	check(err)
//
//	b1 := make([]byte, 5)
//	n1, err := f.Read(b1)
//	check(err)
//	fmt.Printf("%d bytes: %s\n", n1, string(b1[:n1]))
//
//	o2, err := f.Seek(6, 0)
//	check(err)
//	b2 := make([]byte, 2)
//	n2, err := f.Read(b2)
//	check(err)
//	fmt.Printf("%d bytes @ %d: ", n2, o2)
//	fmt.Printf("%v\n", string(b2[:n2]))
//
//	o3, err := f.Seek(6, 0)
//	check(err)
//	b3 := make([]byte, 2)
//	n3, err := io.ReadAtLeast(f, b3, 2)
//	check(err)
//	fmt.Printf("%d bytes @ %d: %s\n", n3, o3, string(b3))
//
//	_, err = f.Seek(0, 0)
//	check(err)
//
//	r4 := bufio.NewReader(f)
//	b4, err := r4.Peek(5)
//	check(err)
//	fmt.Printf("5 bytes: %s\n", string(b4))
//
//	f.Close()
//}

